package com.hzhr.extdevice.model.database.device;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class DevRegulatorCollectDataExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public DevRegulatorCollectDataExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdIsNull() {
            addCriterion("COLLECT_DEVICE_ID is null");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdIsNotNull() {
            addCriterion("COLLECT_DEVICE_ID is not null");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdEqualTo(Integer value) {
            addCriterion("COLLECT_DEVICE_ID =", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdNotEqualTo(Integer value) {
            addCriterion("COLLECT_DEVICE_ID <>", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdGreaterThan(Integer value) {
            addCriterion("COLLECT_DEVICE_ID >", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("COLLECT_DEVICE_ID >=", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdLessThan(Integer value) {
            addCriterion("COLLECT_DEVICE_ID <", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdLessThanOrEqualTo(Integer value) {
            addCriterion("COLLECT_DEVICE_ID <=", value, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdIn(List<Integer> values) {
            addCriterion("COLLECT_DEVICE_ID in", values, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdNotIn(List<Integer> values) {
            addCriterion("COLLECT_DEVICE_ID not in", values, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdBetween(Integer value1, Integer value2) {
            addCriterion("COLLECT_DEVICE_ID between", value1, value2, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andCollectDeviceIdNotBetween(Integer value1, Integer value2) {
            addCriterion("COLLECT_DEVICE_ID not between", value1, value2, "collectDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdIsNull() {
            addCriterion("IOT_DEVICE_ID is null");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdIsNotNull() {
            addCriterion("IOT_DEVICE_ID is not null");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdEqualTo(Integer value) {
            addCriterion("IOT_DEVICE_ID =", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdNotEqualTo(Integer value) {
            addCriterion("IOT_DEVICE_ID <>", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdGreaterThan(Integer value) {
            addCriterion("IOT_DEVICE_ID >", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("IOT_DEVICE_ID >=", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdLessThan(Integer value) {
            addCriterion("IOT_DEVICE_ID <", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdLessThanOrEqualTo(Integer value) {
            addCriterion("IOT_DEVICE_ID <=", value, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdIn(List<Integer> values) {
            addCriterion("IOT_DEVICE_ID in", values, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdNotIn(List<Integer> values) {
            addCriterion("IOT_DEVICE_ID not in", values, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdBetween(Integer value1, Integer value2) {
            addCriterion("IOT_DEVICE_ID between", value1, value2, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andIotDeviceIdNotBetween(Integer value1, Integer value2) {
            addCriterion("IOT_DEVICE_ID not between", value1, value2, "iotDeviceId");
            return (Criteria) this;
        }

        public Criteria andPressureIsNull() {
            addCriterion("PRESSURE is null");
            return (Criteria) this;
        }

        public Criteria andPressureIsNotNull() {
            addCriterion("PRESSURE is not null");
            return (Criteria) this;
        }

        public Criteria andPressureEqualTo(Double value) {
            addCriterion("PRESSURE =", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureNotEqualTo(Double value) {
            addCriterion("PRESSURE <>", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureGreaterThan(Double value) {
            addCriterion("PRESSURE >", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureGreaterThanOrEqualTo(Double value) {
            addCriterion("PRESSURE >=", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureLessThan(Double value) {
            addCriterion("PRESSURE <", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureLessThanOrEqualTo(Double value) {
            addCriterion("PRESSURE <=", value, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureIn(List<Double> values) {
            addCriterion("PRESSURE in", values, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureNotIn(List<Double> values) {
            addCriterion("PRESSURE not in", values, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureBetween(Double value1, Double value2) {
            addCriterion("PRESSURE between", value1, value2, "pressure");
            return (Criteria) this;
        }

        public Criteria andPressureNotBetween(Double value1, Double value2) {
            addCriterion("PRESSURE not between", value1, value2, "pressure");
            return (Criteria) this;
        }

        public Criteria andInPressureIsNull() {
            addCriterion("IN_PRESSURE is null");
            return (Criteria) this;
        }

        public Criteria andInPressureIsNotNull() {
            addCriterion("IN_PRESSURE is not null");
            return (Criteria) this;
        }

        public Criteria andInPressureEqualTo(Double value) {
            addCriterion("IN_PRESSURE =", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureNotEqualTo(Double value) {
            addCriterion("IN_PRESSURE <>", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureGreaterThan(Double value) {
            addCriterion("IN_PRESSURE >", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureGreaterThanOrEqualTo(Double value) {
            addCriterion("IN_PRESSURE >=", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureLessThan(Double value) {
            addCriterion("IN_PRESSURE <", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureLessThanOrEqualTo(Double value) {
            addCriterion("IN_PRESSURE <=", value, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureIn(List<Double> values) {
            addCriterion("IN_PRESSURE in", values, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureNotIn(List<Double> values) {
            addCriterion("IN_PRESSURE not in", values, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureBetween(Double value1, Double value2) {
            addCriterion("IN_PRESSURE between", value1, value2, "inPressure");
            return (Criteria) this;
        }

        public Criteria andInPressureNotBetween(Double value1, Double value2) {
            addCriterion("IN_PRESSURE not between", value1, value2, "inPressure");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureIsNull() {
            addCriterion("ENV_TEMPERATURE is null");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureIsNotNull() {
            addCriterion("ENV_TEMPERATURE is not null");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureEqualTo(Float value) {
            addCriterion("ENV_TEMPERATURE =", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureNotEqualTo(Float value) {
            addCriterion("ENV_TEMPERATURE <>", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureGreaterThan(Float value) {
            addCriterion("ENV_TEMPERATURE >", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureGreaterThanOrEqualTo(Float value) {
            addCriterion("ENV_TEMPERATURE >=", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureLessThan(Float value) {
            addCriterion("ENV_TEMPERATURE <", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureLessThanOrEqualTo(Float value) {
            addCriterion("ENV_TEMPERATURE <=", value, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureIn(List<Float> values) {
            addCriterion("ENV_TEMPERATURE in", values, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureNotIn(List<Float> values) {
            addCriterion("ENV_TEMPERATURE not in", values, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureBetween(Float value1, Float value2) {
            addCriterion("ENV_TEMPERATURE between", value1, value2, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andEnvTemperatureNotBetween(Float value1, Float value2) {
            addCriterion("ENV_TEMPERATURE not between", value1, value2, "envTemperature");
            return (Criteria) this;
        }

        public Criteria andOutPressure1IsNull() {
            addCriterion("OUT_PRESSURE1 is null");
            return (Criteria) this;
        }

        public Criteria andOutPressure1IsNotNull() {
            addCriterion("OUT_PRESSURE1 is not null");
            return (Criteria) this;
        }

        public Criteria andOutPressure1EqualTo(Double value) {
            addCriterion("OUT_PRESSURE1 =", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1NotEqualTo(Double value) {
            addCriterion("OUT_PRESSURE1 <>", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1GreaterThan(Double value) {
            addCriterion("OUT_PRESSURE1 >", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE1 >=", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1LessThan(Double value) {
            addCriterion("OUT_PRESSURE1 <", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1LessThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE1 <=", value, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1In(List<Double> values) {
            addCriterion("OUT_PRESSURE1 in", values, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1NotIn(List<Double> values) {
            addCriterion("OUT_PRESSURE1 not in", values, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1Between(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE1 between", value1, value2, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure1NotBetween(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE1 not between", value1, value2, "outPressure1");
            return (Criteria) this;
        }

        public Criteria andOutPressure2IsNull() {
            addCriterion("OUT_PRESSURE2 is null");
            return (Criteria) this;
        }

        public Criteria andOutPressure2IsNotNull() {
            addCriterion("OUT_PRESSURE2 is not null");
            return (Criteria) this;
        }

        public Criteria andOutPressure2EqualTo(Double value) {
            addCriterion("OUT_PRESSURE2 =", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2NotEqualTo(Double value) {
            addCriterion("OUT_PRESSURE2 <>", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2GreaterThan(Double value) {
            addCriterion("OUT_PRESSURE2 >", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE2 >=", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2LessThan(Double value) {
            addCriterion("OUT_PRESSURE2 <", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2LessThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE2 <=", value, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2In(List<Double> values) {
            addCriterion("OUT_PRESSURE2 in", values, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2NotIn(List<Double> values) {
            addCriterion("OUT_PRESSURE2 not in", values, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2Between(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE2 between", value1, value2, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure2NotBetween(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE2 not between", value1, value2, "outPressure2");
            return (Criteria) this;
        }

        public Criteria andOutPressure3IsNull() {
            addCriterion("OUT_PRESSURE3 is null");
            return (Criteria) this;
        }

        public Criteria andOutPressure3IsNotNull() {
            addCriterion("OUT_PRESSURE3 is not null");
            return (Criteria) this;
        }

        public Criteria andOutPressure3EqualTo(Double value) {
            addCriterion("OUT_PRESSURE3 =", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3NotEqualTo(Double value) {
            addCriterion("OUT_PRESSURE3 <>", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3GreaterThan(Double value) {
            addCriterion("OUT_PRESSURE3 >", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE3 >=", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3LessThan(Double value) {
            addCriterion("OUT_PRESSURE3 <", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3LessThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE3 <=", value, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3In(List<Double> values) {
            addCriterion("OUT_PRESSURE3 in", values, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3NotIn(List<Double> values) {
            addCriterion("OUT_PRESSURE3 not in", values, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3Between(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE3 between", value1, value2, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure3NotBetween(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE3 not between", value1, value2, "outPressure3");
            return (Criteria) this;
        }

        public Criteria andOutPressure4IsNull() {
            addCriterion("OUT_PRESSURE4 is null");
            return (Criteria) this;
        }

        public Criteria andOutPressure4IsNotNull() {
            addCriterion("OUT_PRESSURE4 is not null");
            return (Criteria) this;
        }

        public Criteria andOutPressure4EqualTo(Double value) {
            addCriterion("OUT_PRESSURE4 =", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4NotEqualTo(Double value) {
            addCriterion("OUT_PRESSURE4 <>", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4GreaterThan(Double value) {
            addCriterion("OUT_PRESSURE4 >", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE4 >=", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4LessThan(Double value) {
            addCriterion("OUT_PRESSURE4 <", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4LessThanOrEqualTo(Double value) {
            addCriterion("OUT_PRESSURE4 <=", value, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4In(List<Double> values) {
            addCriterion("OUT_PRESSURE4 in", values, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4NotIn(List<Double> values) {
            addCriterion("OUT_PRESSURE4 not in", values, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4Between(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE4 between", value1, value2, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutPressure4NotBetween(Double value1, Double value2) {
            addCriterion("OUT_PRESSURE4 not between", value1, value2, "outPressure4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1IsNull() {
            addCriterion("OUT_TEMPERATURE1 is null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1IsNotNull() {
            addCriterion("OUT_TEMPERATURE1 is not null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1EqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE1 =", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1NotEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE1 <>", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1GreaterThan(Float value) {
            addCriterion("OUT_TEMPERATURE1 >", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1GreaterThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE1 >=", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1LessThan(Float value) {
            addCriterion("OUT_TEMPERATURE1 <", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1LessThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE1 <=", value, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1In(List<Float> values) {
            addCriterion("OUT_TEMPERATURE1 in", values, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1NotIn(List<Float> values) {
            addCriterion("OUT_TEMPERATURE1 not in", values, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1Between(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE1 between", value1, value2, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature1NotBetween(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE1 not between", value1, value2, "outTemperature1");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2IsNull() {
            addCriterion("OUT_TEMPERATURE2 is null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2IsNotNull() {
            addCriterion("OUT_TEMPERATURE2 is not null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2EqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE2 =", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2NotEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE2 <>", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2GreaterThan(Float value) {
            addCriterion("OUT_TEMPERATURE2 >", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2GreaterThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE2 >=", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2LessThan(Float value) {
            addCriterion("OUT_TEMPERATURE2 <", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2LessThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE2 <=", value, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2In(List<Float> values) {
            addCriterion("OUT_TEMPERATURE2 in", values, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2NotIn(List<Float> values) {
            addCriterion("OUT_TEMPERATURE2 not in", values, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2Between(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE2 between", value1, value2, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature2NotBetween(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE2 not between", value1, value2, "outTemperature2");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3IsNull() {
            addCriterion("OUT_TEMPERATURE3 is null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3IsNotNull() {
            addCriterion("OUT_TEMPERATURE3 is not null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3EqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE3 =", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3NotEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE3 <>", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3GreaterThan(Float value) {
            addCriterion("OUT_TEMPERATURE3 >", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3GreaterThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE3 >=", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3LessThan(Float value) {
            addCriterion("OUT_TEMPERATURE3 <", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3LessThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE3 <=", value, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3In(List<Float> values) {
            addCriterion("OUT_TEMPERATURE3 in", values, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3NotIn(List<Float> values) {
            addCriterion("OUT_TEMPERATURE3 not in", values, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3Between(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE3 between", value1, value2, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature3NotBetween(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE3 not between", value1, value2, "outTemperature3");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4IsNull() {
            addCriterion("OUT_TEMPERATURE4 is null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4IsNotNull() {
            addCriterion("OUT_TEMPERATURE4 is not null");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4EqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE4 =", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4NotEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE4 <>", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4GreaterThan(Float value) {
            addCriterion("OUT_TEMPERATURE4 >", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4GreaterThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE4 >=", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4LessThan(Float value) {
            addCriterion("OUT_TEMPERATURE4 <", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4LessThanOrEqualTo(Float value) {
            addCriterion("OUT_TEMPERATURE4 <=", value, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4In(List<Float> values) {
            addCriterion("OUT_TEMPERATURE4 in", values, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4NotIn(List<Float> values) {
            addCriterion("OUT_TEMPERATURE4 not in", values, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4Between(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE4 between", value1, value2, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutTemperature4NotBetween(Float value1, Float value2) {
            addCriterion("OUT_TEMPERATURE4 not between", value1, value2, "outTemperature4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1IsNull() {
            addCriterion("OUT_STA_TOTAL_FLOW1 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1IsNotNull() {
            addCriterion("OUT_STA_TOTAL_FLOW1 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1EqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 =", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1NotEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 <>", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1GreaterThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 >", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 >=", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1LessThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 <", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW1 <=", value, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1In(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW1 in", values, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1NotIn(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW1 not in", values, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1Between(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW1 between", value1, value2, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow1NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW1 not between", value1, value2, "outStaTotalFlow1");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2IsNull() {
            addCriterion("OUT_STA_TOTAL_FLOW2 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2IsNotNull() {
            addCriterion("OUT_STA_TOTAL_FLOW2 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2EqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 =", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2NotEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 <>", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2GreaterThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 >", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 >=", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2LessThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 <", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW2 <=", value, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2In(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW2 in", values, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2NotIn(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW2 not in", values, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2Between(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW2 between", value1, value2, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow2NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW2 not between", value1, value2, "outStaTotalFlow2");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3IsNull() {
            addCriterion("OUT_STA_TOTAL_FLOW3 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3IsNotNull() {
            addCriterion("OUT_STA_TOTAL_FLOW3 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3EqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 =", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3NotEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 <>", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3GreaterThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 >", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 >=", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3LessThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 <", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW3 <=", value, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3In(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW3 in", values, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3NotIn(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW3 not in", values, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3Between(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW3 between", value1, value2, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow3NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW3 not between", value1, value2, "outStaTotalFlow3");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4IsNull() {
            addCriterion("OUT_STA_TOTAL_FLOW4 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4IsNotNull() {
            addCriterion("OUT_STA_TOTAL_FLOW4 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4EqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 =", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4NotEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 <>", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4GreaterThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 >", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 >=", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4LessThan(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 <", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_TOTAL_FLOW4 <=", value, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4In(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW4 in", values, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4NotIn(List<Double> values) {
            addCriterion("OUT_STA_TOTAL_FLOW4 not in", values, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4Between(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW4 between", value1, value2, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaTotalFlow4NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_TOTAL_FLOW4 not between", value1, value2, "outStaTotalFlow4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1IsNull() {
            addCriterion("OUT_STA_FLOW_RATE1 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1IsNotNull() {
            addCriterion("OUT_STA_FLOW_RATE1 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1EqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 =", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1NotEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 <>", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1GreaterThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 >", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 >=", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1LessThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 <", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE1 <=", value, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1In(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE1 in", values, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1NotIn(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE1 not in", values, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1Between(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE1 between", value1, value2, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate1NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE1 not between", value1, value2, "outStaFlowRate1");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2IsNull() {
            addCriterion("OUT_STA_FLOW_RATE2 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2IsNotNull() {
            addCriterion("OUT_STA_FLOW_RATE2 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2EqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 =", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2NotEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 <>", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2GreaterThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 >", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 >=", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2LessThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 <", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE2 <=", value, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2In(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE2 in", values, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2NotIn(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE2 not in", values, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2Between(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE2 between", value1, value2, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate2NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE2 not between", value1, value2, "outStaFlowRate2");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3IsNull() {
            addCriterion("OUT_STA_FLOW_RATE3 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3IsNotNull() {
            addCriterion("OUT_STA_FLOW_RATE3 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3EqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 =", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3NotEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 <>", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3GreaterThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 >", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 >=", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3LessThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 <", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE3 <=", value, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3In(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE3 in", values, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3NotIn(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE3 not in", values, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3Between(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE3 between", value1, value2, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate3NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE3 not between", value1, value2, "outStaFlowRate3");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4IsNull() {
            addCriterion("OUT_STA_FLOW_RATE4 is null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4IsNotNull() {
            addCriterion("OUT_STA_FLOW_RATE4 is not null");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4EqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 =", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4NotEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 <>", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4GreaterThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 >", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4GreaterThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 >=", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4LessThan(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 <", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4LessThanOrEqualTo(Double value) {
            addCriterion("OUT_STA_FLOW_RATE4 <=", value, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4In(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE4 in", values, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4NotIn(List<Double> values) {
            addCriterion("OUT_STA_FLOW_RATE4 not in", values, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4Between(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE4 between", value1, value2, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andOutStaFlowRate4NotBetween(Double value1, Double value2) {
            addCriterion("OUT_STA_FLOW_RATE4 not between", value1, value2, "outStaFlowRate4");
            return (Criteria) this;
        }

        public Criteria andCollectTimeIsNull() {
            addCriterion("COLLECT_TIME is null");
            return (Criteria) this;
        }

        public Criteria andCollectTimeIsNotNull() {
            addCriterion("COLLECT_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andCollectTimeEqualTo(Date value) {
            addCriterion("COLLECT_TIME =", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeNotEqualTo(Date value) {
            addCriterion("COLLECT_TIME <>", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeGreaterThan(Date value) {
            addCriterion("COLLECT_TIME >", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("COLLECT_TIME >=", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeLessThan(Date value) {
            addCriterion("COLLECT_TIME <", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeLessThanOrEqualTo(Date value) {
            addCriterion("COLLECT_TIME <=", value, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeIn(List<Date> values) {
            addCriterion("COLLECT_TIME in", values, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeNotIn(List<Date> values) {
            addCriterion("COLLECT_TIME not in", values, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeBetween(Date value1, Date value2) {
            addCriterion("COLLECT_TIME between", value1, value2, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCollectTimeNotBetween(Date value1, Date value2) {
            addCriterion("COLLECT_TIME not between", value1, value2, "collectTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNull() {
            addCriterion("CREATE_TIME is null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIsNotNull() {
            addCriterion("CREATE_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andCreateTimeEqualTo(Date value) {
            addCriterion("CREATE_TIME =", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotEqualTo(Date value) {
            addCriterion("CREATE_TIME <>", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThan(Date value) {
            addCriterion("CREATE_TIME >", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("CREATE_TIME >=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThan(Date value) {
            addCriterion("CREATE_TIME <", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
            addCriterion("CREATE_TIME <=", value, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeIn(List<Date> values) {
            addCriterion("CREATE_TIME in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotIn(List<Date> values) {
            addCriterion("CREATE_TIME not in", values, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeBetween(Date value1, Date value2) {
            addCriterion("CREATE_TIME between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
            addCriterion("CREATE_TIME not between", value1, value2, "createTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIsNull() {
            addCriterion("UPDATE_TIME is null");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIsNotNull() {
            addCriterion("UPDATE_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeEqualTo(Date value) {
            addCriterion("UPDATE_TIME =", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotEqualTo(Date value) {
            addCriterion("UPDATE_TIME <>", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeGreaterThan(Date value) {
            addCriterion("UPDATE_TIME >", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("UPDATE_TIME >=", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeLessThan(Date value) {
            addCriterion("UPDATE_TIME <", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeLessThanOrEqualTo(Date value) {
            addCriterion("UPDATE_TIME <=", value, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeIn(List<Date> values) {
            addCriterion("UPDATE_TIME in", values, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotIn(List<Date> values) {
            addCriterion("UPDATE_TIME not in", values, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeBetween(Date value1, Date value2) {
            addCriterion("UPDATE_TIME between", value1, value2, "updateTime");
            return (Criteria) this;
        }

        public Criteria andUpdateTimeNotBetween(Date value1, Date value2) {
            addCriterion("UPDATE_TIME not between", value1, value2, "updateTime");
            return (Criteria) this;
        }

        public Criteria andIsValidIsNull() {
            addCriterion("IS_VALID is null");
            return (Criteria) this;
        }

        public Criteria andIsValidIsNotNull() {
            addCriterion("IS_VALID is not null");
            return (Criteria) this;
        }

        public Criteria andIsValidEqualTo(String value) {
            addCriterion("IS_VALID =", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidNotEqualTo(String value) {
            addCriterion("IS_VALID <>", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidGreaterThan(String value) {
            addCriterion("IS_VALID >", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidGreaterThanOrEqualTo(String value) {
            addCriterion("IS_VALID >=", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidLessThan(String value) {
            addCriterion("IS_VALID <", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidLessThanOrEqualTo(String value) {
            addCriterion("IS_VALID <=", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidLike(String value) {
            addCriterion("IS_VALID like", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidNotLike(String value) {
            addCriterion("IS_VALID not like", value, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidIn(List<String> values) {
            addCriterion("IS_VALID in", values, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidNotIn(List<String> values) {
            addCriterion("IS_VALID not in", values, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidBetween(String value1, String value2) {
            addCriterion("IS_VALID between", value1, value2, "isValid");
            return (Criteria) this;
        }

        public Criteria andIsValidNotBetween(String value1, String value2) {
            addCriterion("IS_VALID not between", value1, value2, "isValid");
            return (Criteria) this;
        }

        public Criteria andStateIsNull() {
            addCriterion("STATE is null");
            return (Criteria) this;
        }

        public Criteria andStateIsNotNull() {
            addCriterion("STATE is not null");
            return (Criteria) this;
        }

        public Criteria andStateEqualTo(String value) {
            addCriterion("STATE =", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateNotEqualTo(String value) {
            addCriterion("STATE <>", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateGreaterThan(String value) {
            addCriterion("STATE >", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateGreaterThanOrEqualTo(String value) {
            addCriterion("STATE >=", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateLessThan(String value) {
            addCriterion("STATE <", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateLessThanOrEqualTo(String value) {
            addCriterion("STATE <=", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateLike(String value) {
            addCriterion("STATE like", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateNotLike(String value) {
            addCriterion("STATE not like", value, "state");
            return (Criteria) this;
        }

        public Criteria andStateIn(List<String> values) {
            addCriterion("STATE in", values, "state");
            return (Criteria) this;
        }

        public Criteria andStateNotIn(List<String> values) {
            addCriterion("STATE not in", values, "state");
            return (Criteria) this;
        }

        public Criteria andStateBetween(String value1, String value2) {
            addCriterion("STATE between", value1, value2, "state");
            return (Criteria) this;
        }

        public Criteria andStateNotBetween(String value1, String value2) {
            addCriterion("STATE not between", value1, value2, "state");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}